#include "gdkinternals.h"
-#include "gdkregion-generic.h"
#include "gdkalias.h"
#include "cairo-directfb.h"
gdk_directfb_clip_region (GdkDrawable *drawable,
GdkGC *gc,
GdkRectangle *draw_rect,
- GdkRegion *ret_clip)
+ cairo_region_t *ret_clip)
{
GdkDrawableImplDirectFB *private;
GdkRectangle rect;
if (gc)
{
GdkGCDirectFB *gc_private = GDK_GC_DIRECTFB (gc);
- GdkRegion *region = &gc_private->clip_region;
+ cairo_region_t *region = &gc_private->clip_region;
if (region->numRects)
{
!GDK_WINDOW_OBJECT (private->wrapper)->input_only)
{
GList *cur;
- GdkRegion temp;
+ cairo_region_t temp;
temp.numRects = 1;
temp.rects = &temp.extents;
gint height)
{
GdkDrawableImplDirectFB *impl;
- GdkRegion clip;
+ cairo_region_t clip;
GdkGCDirectFB *gc_private = NULL;
IDirectFBSurface *surface = NULL;
gint i;
for (i = 0; i < clip.numRects; i++)
{
- GdkRegionBox *box = &clip.rects[i];
+ cairo_region_tBox *box = &clip.rects[i];
rects[i].x = box->x1;
rects[i].y = box->y1;
points[0].y == points[npoints-1].y))
{
GdkDrawableImplDirectFB *impl;
- GdkRegion clip;
+ cairo_region_t clip;
gint i;
impl = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
{
GdkDrawableImplDirectFB *impl;
GdkDrawableImplDirectFB *src_impl;
- GdkRegion clip;
+ cairo_region_t clip;
GdkRectangle dest_rect = { xdest,
ydest,
xdest + width ,
gint npoints)
{
GdkDrawableImplDirectFB *impl;
- GdkRegion clip;
+ cairo_region_t clip;
DFBRegion region = { points->x, points->y, points->x, points->y };
gint nsegs)
{
GdkDrawableImplDirectFB *impl;
- GdkRegion clip;
+ cairo_region_t clip;
gint i;
// DFBRegion region = { segs->x1, segs->y1, segs->x2, segs->y2 };
gint npoints)
{
GdkDrawableImplDirectFB *impl;
- GdkRegion clip;
+ cairo_region_t clip;
gint i;
DFBRegion lines[npoints > 1 ? npoints - 1 : 1];
{
GdkDrawableImplDirectFB *impl;
GdkImageDirectFB *image_private;
- GdkRegion clip;
+ cairo_region_t clip;
GdkRectangle dest_rect = { xdest, ydest, width, height };
gint pitch = 0;
{
GdkPixbuf *composited = NULL;
#if 0
- GdkRegion *clip;
- GdkRegion *drect;
+ cairo_region_t *clip;
+ cairo_region_t *drect;
GdkRectangle tmp_rect;
#endif
GdkDrawableImplDirectFB *impl = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
#include "gdkgc.h"
#include "gdkpixmap.h"
-#include "gdkregion-generic.h"
#include "gdkalias.h"
void
_gdk_windowing_gc_set_clip_region (GdkGC *gc,
- const GdkRegion *region,
+ const cairo_region_t *region,
gboolean reset_origin)
{
GdkGCDirectFB *data;
gboolean
_gdk_windowing_window_queue_antiexpose (GdkWindow *window,
- GdkRegion *area)
+ cairo_region_t *area)
{
return FALSE;
}
{
GdkWindowObject *private;
GdkDrawableImplDirectFB *impl;
- GdkRegion *invalidate_region = NULL;
+ cairo_region_t *invalidate_region = NULL;
GList *list;
g_return_if_fail (GDK_IS_WINDOW (window));
(!private->update_area ||
!cairo_region_contains_rectangle (private->update_area, &rect)))
{
- GdkRegion *region;
+ cairo_region_t *region;
region = cairo_region_create_rectangle (&rect);
cairo_region_subtract (invalidate_region, region);
/**
* gdk_window_move_region:
* @window: a #GdkWindow
- * @region: The #GdkRegion to move
+ * @region: The #cairo_region_t to move
* @dx: Amount to move in the X direction
* @dy: Amount to move in the Y direction
*
**/
void
_gdk_directfb_window_move_region (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
gint dx,
gint dy)
{
GdkWindowObject *private;
GdkDrawableImplDirectFB *impl;
- GdkRegion *window_clip;
- GdkRegion *src_region;
- GdkRegion *brought_in;
- GdkRegion *dest_region;
- GdkRegion *moving_invalid_region;
+ cairo_region_t *window_clip;
+ cairo_region_t *src_region;
+ cairo_region_t *brought_in;
+ cairo_region_t *dest_region;
+ cairo_region_t *moving_invalid_region;
GdkRectangle dest_extents;
g_return_if_fail (GDK_IS_WINDOW (window));
#include "gdkinternals.h"
#include "gdkcursor.h"
#include "gdkdisplay-directfb.h"
-#include "gdkregion-generic.h"
#include <cairo.h>
#include <string.h>
gboolean buffered;
- GdkRegion paint_region;
+ cairo_region_t paint_region;
gint paint_depth;
gint width;
gint height;
gint abs_x;
gint abs_y;
- GdkRegion clip_region;
+ cairo_region_t clip_region;
GdkColormap *colormap;
gint dx,
gint dy);
void _gdk_directfb_window_move_region (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
gint dx,
gint dy);
{
GdkGC parent_instance;
- GdkRegion clip_region;
+ cairo_region_t clip_region;
GdkGCValuesMask values_mask;
GdkGCValues values;
void gdk_directfb_clip_region (GdkDrawable *drawable,
GdkGC *gc,
GdkRectangle *draw_rect,
- GdkRegion *ret_clip);
+ cairo_region_t *ret_clip);
/* Utilities for avoiding mallocs */
static inline void
-temp_region_init_copy( GdkRegion *region,
- const GdkRegion *source)
+temp_region_init_copy( cairo_region_t *region,
+ const cairo_region_t *source)
{
if (region != source) /* don't want to copy to itself */
{
if (region->rects && region->rects != ®ion->extents)
g_free( region->rects );
- region->rects = g_new (GdkRegionBox, source->numRects);
+ region->rects = g_new (cairo_region_tBox, source->numRects);
region->size = source->numRects;
}
region->numRects = source->numRects;
region->extents = source->extents;
- memcpy( region->rects, source->rects, source->numRects * sizeof (GdkRegionBox) );
+ memcpy( region->rects, source->rects, source->numRects * sizeof (cairo_region_tBox) );
}
}
static inline void
-temp_region_init_rectangle( GdkRegion *region,
+temp_region_init_rectangle( cairo_region_t *region,
const GdkRectangle *rect )
{
region->numRects = 1;
}
static inline void
-temp_region_init_rectangle_vals( GdkRegion *region,
+temp_region_init_rectangle_vals( cairo_region_t *region,
int x,
int y,
int w,
}
static inline void
-temp_region_reset( GdkRegion *region )
+temp_region_reset( cairo_region_t *region )
{
if (region->size > 32 && region->rects && region->rects != ®ion->extents) {
g_free( region->rects );
}
static inline void
-temp_region_deinit( GdkRegion *region )
+temp_region_deinit( cairo_region_t *region )
{
if (region->rects && region->rects != ®ion->extents) {
g_free( region->rects );
#include "gdkprivate-directfb.h"
#include "gdkdisplay-directfb.h"
-#include "gdkregion-generic.h"
-
#include "gdkinternals.h"
#include "gdkalias.h"
#include "cairo.h"
D_DEBUG_DOMAIN( GDKDFB_Window, "GDKDFB/Window", "GDK DirectFB Window" );
-static GdkRegion * gdk_window_impl_directfb_get_visible_region (GdkDrawable *drawable);
+static cairo_region_t * gdk_window_impl_directfb_get_visible_region (GdkDrawable *drawable);
static void gdk_window_impl_directfb_set_colormap (GdkDrawable *drawable,
GdkColormap *colormap);
static void gdk_window_impl_directfb_init (GdkWindowImplDirectFB *window);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
-static GdkRegion*
+static cairo_region_t*
gdk_window_impl_directfb_get_visible_region (GdkDrawable *drawable)
{
GdkDrawableImplDirectFB *priv = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
static void
gdk_directfb_window_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
void
gdk_directfb_window_input_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
static void
gdk_directfb_window_queue_translation (GdkWindow *window,
GdkGC *gc,
- GdkRegion *region,
+ cairo_region_t *region,
gint dx,
gint dy)
{
static void
gdk_window_impl_directfb_begin_paint_region (GdkPaintable *paintable,
GdkWindow *window,
- const GdkRegion *region)
+ const cairo_region_t *region)
{
GdkDrawableImplDirectFB *impl;
GdkWindowImplDirectFB *wimpl;
for (i = 0; i < region->numRects; i++)
{
- GdkRegionBox *box = ®ion->rects[i];
+ cairo_region_tBox *box = ®ion->rects[i];
D_DEBUG_AT( GDKDFB_Window, " -> [%2d] %4d,%4d-%4dx%4d\n", i, GDKDFB_RECTANGLE_VALS_FROM_BOX( box ) );
D_DEBUG_AT( GDKDFB_Window, " -> depth is still %d\n", impl->paint_depth );
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_get_shape_for_mask (GdkBitmap *mask)
{
return NULL;
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_window_get_shape (GdkWindow *window)
{
return NULL;
return 0;
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_window_get_input_shape (GdkWindow *window)
{
return NULL;
void
_gdk_windowing_window_process_updates_recurse (GdkWindow *window,
- GdkRegion *region)
+ cairo_region_t *region)
{
_gdk_window_process_updates_recurse (window, region);
}
static gboolean
gdk_directfb_window_queue_antiexpose (GdkWindow *window,
- GdkRegion *area)
+ cairo_region_t *area)
{
return FALSE;
}
/**
* gdk_cairo_region:
* @cr: a #cairo_t
- * @region: a #GdkRegion
+ * @region: a #cairo_region_t
*
* Adds the given region to the current path of @cr.
*
**/
void
gdk_cairo_region (cairo_t *cr,
- const GdkRegion *region)
+ const cairo_region_t *region)
{
cairo_rectangle_int_t box;
gint n_boxes, i;
void gdk_cairo_rectangle (cairo_t *cr,
const GdkRectangle *rectangle);
void gdk_cairo_region (cairo_t *cr,
- const GdkRegion *region);
+ const cairo_region_t *region);
G_END_DECLS
gint height,
gint *composite_x_offset,
gint *composite_y_offset);
-static GdkRegion * gdk_drawable_real_get_visible_region (GdkDrawable *drawable);
+static cairo_region_t * gdk_drawable_real_get_visible_region (GdkDrawable *drawable);
static void gdk_drawable_real_draw_pixbuf (GdkDrawable *drawable,
GdkGC *gc,
GdkPixbuf *pixbuf,
* but no area outside of this region will be affected by drawing
* primitives.
*
- * Returns: a #GdkRegion. This must be freed with cairo_region_destroy()
+ * Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
* when you are done.
**/
-GdkRegion *
+cairo_region_t *
gdk_drawable_get_clip_region (GdkDrawable *drawable)
{
g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
* obscured by other windows, but no area outside of this region
* is visible.
*
- * Returns: a #GdkRegion. This must be freed with cairo_region_destroy()
+ * Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
* when you are done.
**/
-GdkRegion *
+cairo_region_t *
gdk_drawable_get_visible_region (GdkDrawable *drawable)
{
g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
return GDK_DRAWABLE_GET_CLASS (drawable)->get_visible_region (drawable);
}
-static GdkRegion *
+static cairo_region_t *
gdk_drawable_real_get_visible_region (GdkDrawable *drawable)
{
GdkRectangle rect;
{
GdkPixbuf *composited = NULL;
gint dwidth, dheight;
- GdkRegion *clip;
- GdkRegion *drect;
+ cairo_region_t *clip;
+ cairo_region_t *drect;
GdkRectangle tmp_rect;
GdkDrawable *real_drawable;
gint width,
gint height);
- GdkRegion* (*get_clip_region) (GdkDrawable *drawable);
- GdkRegion* (*get_visible_region) (GdkDrawable *drawable);
+ cairo_region_t* (*get_clip_region) (GdkDrawable *drawable);
+ cairo_region_t* (*get_visible_region) (GdkDrawable *drawable);
GdkDrawable* (*get_composite_drawable) (GdkDrawable *drawable,
gint x,
gint width,
gint height);
-GdkRegion *gdk_drawable_get_clip_region (GdkDrawable *drawable);
-GdkRegion *gdk_drawable_get_visible_region (GdkDrawable *drawable);
+cairo_region_t *gdk_drawable_get_clip_region (GdkDrawable *drawable);
+cairo_region_t *gdk_drawable_get_visible_region (GdkDrawable *drawable);
G_END_DECLS
GdkWindow *window;
gint8 send_event;
GdkRectangle area;
- GdkRegion *region;
+ cairo_region_t *region;
gint count; /* If non-zero, how many more events follow. */
};
struct _GdkGCPrivate
{
- GdkRegion *clip_region;
+ cairo_region_t *clip_region;
guint32 region_tag_applied;
int region_tag_offset_x;
int region_tag_offset_y;
- GdkRegion *old_clip_region;
+ cairo_region_t *old_clip_region;
GdkPixmap *old_clip_mask;
GdkBitmap *stipple;
/* Takes ownership of passed in region */
static void
_gdk_gc_set_clip_region_real (GdkGC *gc,
- GdkRegion *region,
+ cairo_region_t *region,
gboolean reset_origin)
{
GdkGCPrivate *priv = GDK_GC_GET_PRIVATE (gc);
/* Doesn't copy region, allows not to reset origin */
void
_gdk_gc_set_clip_region_internal (GdkGC *gc,
- GdkRegion *region,
+ cairo_region_t *region,
gboolean reset_origin)
{
_gdk_gc_remove_drawable_clip (gc);
void
_gdk_gc_add_drawable_clip (GdkGC *gc,
guint32 region_tag,
- GdkRegion *region,
+ cairo_region_t *region,
int offset_x,
int offset_y)
{
else if (overlap == CAIRO_REGION_OVERLAP_OUT)
{
/* No intersection, set empty clip region */
- GdkRegion *empty = cairo_region_create ();
+ cairo_region_t *empty = cairo_region_create ();
cairo_region_destroy (region);
priv->old_clip_mask = g_object_ref (priv->clip_mask);
gdk_gc_set_clip_rectangle (GdkGC *gc,
const GdkRectangle *rectangle)
{
- GdkRegion *region;
+ cairo_region_t *region;
g_return_if_fail (GDK_IS_GC (gc));
/**
* gdk_gc_set_clip_region:
* @gc: a #GdkGC.
- * @region: the #GdkRegion.
+ * @region: the #cairo_region_t.
*
* Sets the clip mask for a graphics context from a region structure.
* The clip mask is interpreted relative to the clip origin. (See
**/
void
gdk_gc_set_clip_region (GdkGC *gc,
- const GdkRegion *region)
+ const cairo_region_t *region)
{
- GdkRegion *copy;
+ cairo_region_t *copy;
g_return_if_fail (GDK_IS_GC (gc));
* (if a clip mask is set, the return will be %NULL)
* This value is owned by the GC and must not be freed.
**/
-GdkRegion *
+cairo_region_t *
_gdk_gc_get_clip_region (GdkGC *gc)
{
g_return_val_if_fail (GDK_IS_GC (gc), NULL);
void gdk_gc_set_clip_rectangle (GdkGC *gc,
const GdkRectangle *rectangle);
void gdk_gc_set_clip_region (GdkGC *gc,
- const GdkRegion *region);
+ const cairo_region_t *region);
void gdk_gc_set_subwindow (GdkGC *gc,
GdkSubwindowMode mode);
void gdk_gc_set_exposures (GdkGC *gc,
GSList *paint_stack;
- GdkRegion *update_area;
+ cairo_region_t *update_area;
guint update_freeze_count;
guint8 window_type;
int abs_x, abs_y; /* Absolute offset in impl */
gint width, height;
guint32 clip_tag;
- GdkRegion *clip_region; /* Clip region (wrt toplevel) in window coords */
- GdkRegion *clip_region_with_children; /* Clip region in window coords */
+ cairo_region_t *clip_region; /* Clip region (wrt toplevel) in window coords */
+ cairo_region_t *clip_region_with_children; /* Clip region in window coords */
GdkCursor *cursor;
GHashTable *device_cursor;
gint8 toplevel_window_type;
GList *outstanding_moves;
- GdkRegion *shape;
- GdkRegion *input_shape;
+ cairo_region_t *shape;
+ cairo_region_t *input_shape;
cairo_surface_t *cairo_surface;
guint outstanding_surfaces; /* only set on impl window */
gboolean _gdk_window_update_viewable (GdkWindow *window);
void _gdk_window_process_updates_recurse (GdkWindow *window,
- GdkRegion *expose_region);
+ cairo_region_t *expose_region);
void _gdk_screen_close (GdkScreen *screen);
GdkGCValues *values,
GdkGCValuesMask values_mask);
-GdkRegion *_gdk_gc_get_clip_region (GdkGC *gc);
+cairo_region_t *_gdk_gc_get_clip_region (GdkGC *gc);
GdkBitmap *_gdk_gc_get_clip_mask (GdkGC *gc);
gboolean _gdk_gc_get_exposures (GdkGC *gc);
GdkFill _gdk_gc_get_fill (GdkGC *gc);
guint32 _gdk_gc_get_bg_pixel (GdkGC *gc);
void _gdk_gc_add_drawable_clip (GdkGC *gc,
guint32 region_tag,
- GdkRegion *region,
+ cairo_region_t *region,
int offset_x,
int offset_y);
void _gdk_gc_remove_drawable_clip (GdkGC *gc);
void _gdk_gc_set_clip_region_internal (GdkGC *gc,
- GdkRegion *region,
+ cairo_region_t *region,
gboolean reset_origin);
GdkSubwindowMode _gdk_gc_get_subwindow (GdkGC *gc);
void _gdk_windowing_window_get_offsets (GdkWindow *window,
gint *x_offset,
gint *y_offset);
-GdkRegion *_gdk_windowing_window_get_shape (GdkWindow *window);
-GdkRegion *_gdk_windowing_window_get_input_shape(GdkWindow *window);
-GdkRegion *_gdk_windowing_get_shape_for_mask (GdkBitmap *mask);
+cairo_region_t *_gdk_windowing_window_get_shape (GdkWindow *window);
+cairo_region_t *_gdk_windowing_window_get_input_shape(GdkWindow *window);
+cairo_region_t *_gdk_windowing_get_shape_for_mask (GdkBitmap *mask);
void _gdk_windowing_window_beep (GdkWindow *window);
gulong serial);
void _gdk_windowing_window_process_updates_recurse (GdkWindow *window,
- GdkRegion *expose_region);
+ cairo_region_t *expose_region);
void _gdk_windowing_before_process_all_updates (void);
void _gdk_windowing_after_process_all_updates (void);
void (* begin_paint_region) (GdkPaintable *paintable,
GdkWindow *window,
- const GdkRegion *region);
+ const cairo_region_t *region);
void (* end_paint) (GdkPaintable *paintable);
};
* will already return the new region.
**/
void _gdk_windowing_gc_set_clip_region (GdkGC *gc,
- const GdkRegion *region,
+ const cairo_region_t *region,
gboolean reset_origin);
/**
gpointer user_data);
void _gdk_window_invalidate_for_expose (GdkWindow *window,
- GdkRegion *region);
+ cairo_region_t *region);
void _gdk_windowing_set_cairo_surface_size (cairo_surface_t *surface,
int width,
double *found_y);
void _gdk_window_add_damage (GdkWindow *toplevel,
- GdkRegion *damaged_region);
+ cairo_region_t *damaged_region);
GdkEvent * _gdk_make_event (GdkWindow *window,
GdkEventType type,
void _gdk_synthesize_crossing_events_for_geometry_change (GdkWindow *changed_window);
-GdkRegion *_gdk_window_calculate_full_clip_region (GdkWindow *window,
+cairo_region_t *_gdk_window_calculate_full_clip_region (GdkWindow *window,
GdkWindow *base_window,
gboolean do_children,
gint *base_x_offset,
gboolean is_line)
{
GdkRectangle rect;
- GdkRegion *damage;
+ cairo_region_t *damage;
rect.x = x;
rect.y = y;
static void
gdk_offscreen_window_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
static void
gdk_offscreen_window_input_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
static gboolean
gdk_offscreen_window_queue_antiexpose (GdkWindow *window,
- GdkRegion *area)
+ cairo_region_t *area)
{
return FALSE;
}
static void
gdk_offscreen_window_queue_translation (GdkWindow *window,
GdkGC *gc,
- GdkRegion *area,
+ cairo_region_t *area,
gint dx,
gint dy)
{
* region which contains the given ranges, i.e. if you draw with the
* region as clip, only the given ranges are drawn.
*/
-static GdkRegion*
+static cairo_region_t*
layout_iter_get_line_clip_region (PangoLayoutIter *iter,
gint x_origin,
gint y_origin,
gint n_ranges)
{
PangoLayoutLine *line;
- GdkRegion *clip_region;
+ cairo_region_t *clip_region;
PangoRectangle logical_rect;
gint baseline;
gint i;
*
* Return value: a clip region containing the given ranges
**/
-GdkRegion*
+cairo_region_t*
gdk_pango_layout_line_get_clip_region (PangoLayoutLine *line,
gint x_origin,
gint y_origin,
const gint *index_ranges,
gint n_ranges)
{
- GdkRegion *clip_region;
+ cairo_region_t *clip_region;
PangoLayoutIter *iter;
g_return_val_if_fail (line != NULL, NULL);
*
* Return value: a clip region containing the given ranges
**/
-GdkRegion*
+cairo_region_t*
gdk_pango_layout_get_clip_region (PangoLayout *layout,
gint x_origin,
gint y_origin,
gint n_ranges)
{
PangoLayoutIter *iter;
- GdkRegion *clip_region;
+ cairo_region_t *clip_region;
g_return_val_if_fail (PANGO_IS_LAYOUT (layout), NULL);
g_return_val_if_fail (index_ranges != NULL, NULL);
do
{
PangoRectangle logical_rect;
- GdkRegion *line_region;
+ cairo_region_t *line_region;
gint baseline;
pango_layout_iter_get_line_extents (iter, NULL, &logical_rect);
* draw with the region as clip, only the given ranges are drawn.
*/
-GdkRegion *gdk_pango_layout_line_get_clip_region (PangoLayoutLine *line,
+cairo_region_t *gdk_pango_layout_line_get_clip_region (PangoLayoutLine *line,
gint x_origin,
gint y_origin,
const gint *index_ranges,
gint n_ranges);
-GdkRegion *gdk_pango_layout_get_clip_region (PangoLayout *layout,
+cairo_region_t *gdk_pango_layout_get_clip_region (PangoLayout *layout,
gint x_origin,
gint y_origin,
const gint *index_ranges,
GdkRegion * gdk_region_new (void);
#endif
-GdkRegion * gdk_region_polygon (const GdkPoint *points,
+cairo_region_t * gdk_region_polygon (const GdkPoint *points,
gint n_points,
GdkFillRule fill_rule);
#ifndef GDK_DISABLE_DEPRECATED
gboolean gdk_region_equal (const GdkRegion *region1,
const GdkRegion *region2);
#endif
-gboolean gdk_region_rect_equal (const GdkRegion *region,
- const GdkRectangle *rectangle);
+gboolean gdk_region_rect_equal (const cairo_region_t *region,
+ const GdkRectangle *rectangle);
#ifndef GDK_DISABLE_DEPRECATED
gboolean gdk_region_point_in (const GdkRegion *region,
int x,
typedef struct _GdkCursor GdkCursor;
typedef struct _GdkGC GdkGC;
typedef struct _GdkImage GdkImage;
+#ifndef GDK_DISABLE_DEPRECATED
typedef cairo_region_t GdkRegion;
+#endif
typedef struct _GdkVisual GdkVisual;
typedef struct _GdkDrawable GdkDrawable;
gint y;
};
+#ifndef GDK_DISABLE_DEPRECATED
struct _GdkRectangle
{
gint x;
gint width;
gint height;
};
+#endif
struct _GdkSegment
{
struct _GdkWindowPaint
{
- GdkRegion *region;
+ cairo_region_t *region;
GdkPixmap *pixmap;
gint x_offset;
gint y_offset;
};
typedef struct {
- GdkRegion *dest_region; /* The destination region */
+ cairo_region_t *dest_region; /* The destination region */
int dx, dy; /* The amount that the source was moved to reach dest_region */
} GdkWindowRegionMove;
gint height,
gint *composite_x_offset,
gint *composite_y_offset);
-static GdkRegion* gdk_window_get_clip_region (GdkDrawable *drawable);
-static GdkRegion* gdk_window_get_visible_region (GdkDrawable *drawable);
+static cairo_region_t* gdk_window_get_clip_region (GdkDrawable *drawable);
+static cairo_region_t* gdk_window_get_visible_region (GdkDrawable *drawable);
static void gdk_window_free_paint_stack (GdkWindow *window);
GParamSpec *pspec);
static void gdk_window_clear_backing_region (GdkWindow *window,
- GdkRegion *region);
+ cairo_region_t *region);
static void gdk_window_redirect_free (GdkWindowRedirect *redirect);
static void apply_redirect_to_children (GdkWindowObject *private,
GdkWindowRedirect *redirect);
static void gdk_window_flush_outstanding_moves (GdkWindow *window);
static void gdk_window_flush_recursive (GdkWindowObject *window);
static void do_move_region_bits_on_impl (GdkWindowObject *private,
- GdkRegion *region, /* In impl window coords */
+ cairo_region_t *region, /* In impl window coords */
int dx, int dy);
static void gdk_window_invalidate_in_parent (GdkWindowObject *private);
static void move_native_children (GdkWindowObject *private);
static void update_cursor (GdkDisplay *display,
GdkDevice *device);
static void impl_window_add_update_area (GdkWindowObject *impl_window,
- GdkRegion *region);
+ cairo_region_t *region);
static void gdk_window_region_move_free (GdkWindowRegionMove *move);
static void gdk_window_invalidate_region_full (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
gboolean invalidate_children,
ClearBg clear_bg);
static void gdk_window_invalidate_rect_full (GdkWindow *window,
remove_child_area (GdkWindowObject *private,
GdkWindowObject *until,
gboolean for_input,
- GdkRegion *region)
+ cairo_region_t *region)
{
GdkWindowObject *child;
- GdkRegion *child_region;
+ cairo_region_t *child_region;
GdkRectangle r;
GList *l;
- GdkRegion *shape;
+ cairo_region_t *shape;
for (l = private->children; l; l = l->next)
{
static void
apply_shape (GdkWindowObject *private,
- GdkRegion *region)
+ cairo_region_t *region)
{
GdkWindowImplIface *impl_iface;
GdkRectangle r;
GList *l;
GdkWindowObject *child;
- GdkRegion *new_clip, *old_clip_region_with_children;
+ cairo_region_t *new_clip, *old_clip_region_with_children;
gboolean clip_region_changed;
gboolean abs_pos_changed;
int old_abs_x, old_abs_y;
GdkWindowObject *private = (GdkWindowObject *)window;
GdkWindowObject *impl_window;
GdkWindowPaint *paint;
- GdkRegion *region;
+ cairo_region_t *region;
GdkGC *tmp_gc;
GSList *list;
gdk_window_begin_paint_rect (GdkWindow *window,
const GdkRectangle *rectangle)
{
- GdkRegion *region;
+ cairo_region_t *region;
g_return_if_fail (GDK_IS_WINDOW (window));
**/
void
gdk_window_begin_paint_region (GdkWindow *window,
- const GdkRegion *region)
+ const cairo_region_t *region)
{
#ifdef USE_BACKING_STORE
GdkWindowObject *private = (GdkWindowObject *)window;
int *y_offset_out)
{
GdkWindowObject *private = (GdkWindowObject *)window;
- GdkRegion *visible_region;
+ cairo_region_t *visible_region;
GdkRectangle dest_rect;
- GdkRegion *tmpreg;
+ cairo_region_t *tmpreg;
GdkWindow *toplevel;
int x_offset, y_offset;
GdkGC *tmp_gc;
GdkRectangle clip_box;
gint x_offset, y_offset;
- GdkRegion *full_clip;
+ cairo_region_t *full_clip;
g_return_if_fail (GDK_IS_WINDOW (window));
static void
do_move_region_bits_on_impl (GdkWindowObject *impl_window,
- GdkRegion *dest_region, /* In impl window coords */
+ cairo_region_t *dest_region, /* In impl window coords */
int dx, int dy)
{
GdkGC *tmp_gc;
}
static GdkWindowRegionMove *
-gdk_window_region_move_new (GdkRegion *region,
+gdk_window_region_move_new (cairo_region_t *region,
int dx, int dy)
{
GdkWindowRegionMove *move;
static void
append_move_region (GdkWindowObject *impl_window,
- GdkRegion *new_dest_region,
+ cairo_region_t *new_dest_region,
int dx, int dy)
{
GdkWindowRegionMove *move, *old_move;
- GdkRegion *new_total_region, *old_total_region;
- GdkRegion *source_overlaps_destination;
- GdkRegion *non_overwritten;
+ cairo_region_t *new_total_region, *old_total_region;
+ cairo_region_t *source_overlaps_destination;
+ cairo_region_t *non_overwritten;
gboolean added_move;
GList *l, *prev;
Takes ownership of region to avoid copy (because we may change it) */
static void
move_region_on_impl (GdkWindowObject *impl_window,
- GdkRegion *region, /* In impl window coords */
+ cairo_region_t *region, /* In impl window coords */
int dx, int dy)
{
if ((dx == 0 && dy == 0) ||
/* Move any old invalid regions in the copy source area by dx/dy */
if (impl_window->update_area)
{
- GdkRegion *update_area;
+ cairo_region_t *update_area;
update_area = cairo_region_copy (region);
if (impl_window->implicit_paint)
{
GdkWindowPaint *implicit_paint = impl_window->implicit_paint;
- GdkRegion *exposing;
+ cairo_region_t *exposing;
exposing = cairo_region_copy (implicit_paint->region);
cairo_region_intersect (exposing, region);
GdkDrawable *impl;
gint old_clip_x = gc->clip_x_origin;
gint old_clip_y = gc->clip_y_origin;
- GdkRegion *clip;
+ cairo_region_t *clip;
guint32 clip_region_tag;
GdkWindowPaint *paint;
return tmp_pixmap;
}
-static GdkRegion*
+static cairo_region_t*
gdk_window_get_clip_region (GdkDrawable *drawable)
{
GdkWindowObject *private = (GdkWindowObject *)drawable;
- GdkRegion *result;
+ cairo_region_t *result;
result = cairo_region_copy (private->clip_region);
if (private->paint_stack)
{
- GdkRegion *paint_region = cairo_region_create ();
+ cairo_region_t *paint_region = cairo_region_create ();
GSList *tmp_list = private->paint_stack;
while (tmp_list)
return result;
}
-static GdkRegion*
+static cairo_region_t*
gdk_window_get_visible_region (GdkDrawable *drawable)
{
GdkWindowObject *private = (GdkWindowObject*) drawable;
if (_gdk_gc_get_exposures (gc) &&
GDK_IS_WINDOW (original_src))
{
- GdkRegion *exposure_region;
- GdkRegion *clip;
+ cairo_region_t *exposure_region;
+ cairo_region_t *clip;
GdkRectangle r;
r.x = xdest;
static void
gdk_window_clear_backing_region (GdkWindow *window,
- GdkRegion *region)
+ cairo_region_t *region)
{
GdkWindowObject *private = (GdkWindowObject *)window;
GdkWindowPaint *paint = private->paint_stack->data;
BackingRectMethod method;
- GdkRegion *clip;
+ cairo_region_t *clip;
GdkRectangle clipbox;
#if 0
GTimer *timer;
static void
gdk_window_clear_backing_region_redirect (GdkWindow *window,
- GdkRegion *region)
+ cairo_region_t *region)
{
GdkWindowObject *private = (GdkWindowObject *)window;
GdkWindowRedirect *redirect = private->redirect;
- GdkRegion *clip_region;
+ cairo_region_t *clip_region;
GdkRectangle clipbox;
gint x_offset, y_offset;
BackingRectMethod method;
static void
gdk_window_clear_backing_region_direct (GdkWindow *window,
- GdkRegion *region)
+ cairo_region_t *region)
{
GdkWindowObject *private = (GdkWindowObject *)window;
BackingRectMethod method;
GdkWindowPaint paint;
- GdkRegion *clip;
+ cairo_region_t *clip;
GdkRectangle clipbox;
if (GDK_WINDOW_DESTROYED (window))
static void
gdk_window_clear_region_internal (GdkWindow *window,
- GdkRegion *region,
+ cairo_region_t *region,
gboolean send_expose)
{
GdkWindowObject *private = (GdkWindowObject *)window;
if (impl_iface->clear_region && clears_as_native (private))
{
- GdkRegion *copy;
+ cairo_region_t *copy;
copy = cairo_region_copy (region);
cairo_region_intersect (copy,
private->clip_region_with_children);
gboolean send_expose)
{
GdkRectangle rect;
- GdkRegion *region;
+ cairo_region_t *region;
g_return_if_fail (GDK_IS_WINDOW (window));
void
_gdk_window_process_updates_recurse (GdkWindow *window,
- GdkRegion *expose_region)
+ cairo_region_t *expose_region)
{
GdkWindowObject *private = (GdkWindowObject *)window;
GdkWindowObject *child;
- GdkRegion *child_region;
+ cairo_region_t *child_region;
GdkRectangle r;
GList *l, *children;
*/
if (private->update_area)
{
- GdkRegion *update_area = private->update_area;
+ cairo_region_t *update_area = private->update_area;
private->update_area = NULL;
if (_gdk_event_func && gdk_window_is_viewable (window))
{
- GdkRegion *expose_region;
+ cairo_region_t *expose_region;
gboolean end_implicit;
/* Clip to part visible in toplevel */
if (private->outstanding_moves)
{
GdkWindowRegionMove *move;
- GdkRegion *remove;
+ cairo_region_t *remove;
GList *l, *prev;
remove = cairo_region_copy (update_area);
ClearBg clear_bg)
{
GdkRectangle window_rect;
- GdkRegion *region;
+ cairo_region_t *region;
GdkWindowObject *private = (GdkWindowObject *)window;
g_return_if_fail (GDK_IS_WINDOW (window));
static void
draw_ugly_color (GdkWindow *window,
- const GdkRegion *region)
+ const cairo_region_t *region)
{
/* Draw ugly color all over the newly-invalid region */
GdkColor ugly_color = { 0, 50000, 10000, 10000 };
static void
impl_window_add_update_area (GdkWindowObject *impl_window,
- GdkRegion *region)
+ cairo_region_t *region)
{
if (impl_window->update_area)
cairo_region_union (impl_window->update_area, region);
*/
static void
gdk_window_invalidate_maybe_recurse_full (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
ClearBg clear_bg,
gboolean (*child_func) (GdkWindow *,
gpointer),
{
GdkWindowObject *private = (GdkWindowObject *)window;
GdkWindowObject *impl_window;
- GdkRegion *visible_region;
+ cairo_region_t *visible_region;
GList *tmp_list;
g_return_if_fail (GDK_IS_WINDOW (window));
if (!child->input_only)
{
- GdkRegion *child_region;
+ cairo_region_t *child_region;
GdkRectangle child_rect;
child_rect.x = child->x;
if (child_func && (*child_func) ((GdkWindow *)child, user_data))
{
- GdkRegion *tmp = cairo_region_copy (region);
+ cairo_region_t *tmp = cairo_region_copy (region);
cairo_region_translate (tmp, - child_rect.x, - child_rect.y);
cairo_region_translate (child_region, - child_rect.x, - child_rect.y);
/**
* gdk_window_invalidate_maybe_recurse:
* @window: a #GdkWindow
- * @region: a #GdkRegion
+ * @region: a #cairo_region_t
* @child_func: function to use to decide if to recurse to a child,
* %NULL means never recurse.
* @user_data: data passed to @child_func
**/
void
gdk_window_invalidate_maybe_recurse (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
gboolean (*child_func) (GdkWindow *,
gpointer),
gpointer user_data)
static void
gdk_window_invalidate_region_full (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
gboolean invalidate_children,
ClearBg clear_bg)
{
/**
* gdk_window_invalidate_region:
* @window: a #GdkWindow
- * @region: a #GdkRegion
+ * @region: a #cairo_region_t
* @invalidate_children: %TRUE to also invalidate child windows
*
* Adds @region to the update area for @window. The update area is the
**/
void
gdk_window_invalidate_region (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
gboolean invalidate_children)
{
gdk_window_invalidate_maybe_recurse (window, region,
/**
* _gdk_window_invalidate_for_expose:
* @window: a #GdkWindow
- * @region: a #GdkRegion
+ * @region: a #cairo_region_t
*
* Adds @region to the update area for @window. The update area is the
* region that needs to be redrawn, or "dirty region." The call
**/
void
_gdk_window_invalidate_for_expose (GdkWindow *window,
- GdkRegion *region)
+ cairo_region_t *region)
{
GdkWindowObject *private = (GdkWindowObject *) window;
GdkWindowRegionMove *move;
- GdkRegion *move_region;
+ cairo_region_t *move_region;
GList *l;
/* Any invalidations comming from the windowing system will
*
* Return value: the update area for @window
**/
-GdkRegion *
+cairo_region_t *
gdk_window_get_update_area (GdkWindow *window)
{
GdkWindowObject *private = (GdkWindowObject *)window;
GdkWindowObject *impl_window;
- GdkRegion *tmp_region;
+ cairo_region_t *tmp_region;
g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
gdk_window_raise (GdkWindow *window)
{
GdkWindowObject *private;
- GdkRegion *old_region, *new_region;
+ cairo_region_t *old_region, *new_region;
g_return_if_fail (GDK_IS_WINDOW (window));
gint height)
{
GdkWindowObject *private;
- GdkRegion *old_region, *new_region;
+ cairo_region_t *old_region, *new_region;
GdkWindowImplIface *impl_iface;
gboolean expose;
int old_x, old_y, old_abs_x, old_abs_y;
static gboolean
collect_native_child_region_helper (GdkWindowObject *window,
GdkWindow *impl,
- GdkRegion **region,
+ cairo_region_t **region,
int x_offset,
int y_offset)
{
GdkWindowObject *child;
- GdkRegion *tmp;
+ cairo_region_t *tmp;
GList *l;
for (l = window->children; l != NULL; l = l->next)
return FALSE;
}
-static GdkRegion *
+static cairo_region_t *
collect_native_child_region (GdkWindowObject *window,
gboolean include_this)
{
- GdkRegion *region;
+ cairo_region_t *region;
if (include_this && gdk_window_has_impl (window) && window->viewable)
return cairo_region_copy (window->clip_region);
gint height)
{
GdkWindowObject *private;
- GdkRegion *old_region, *new_region, *copy_area;
- GdkRegion *old_native_child_region, *new_native_child_region;
+ cairo_region_t *old_region, *new_region, *copy_area;
+ cairo_region_t *old_native_child_region, *new_native_child_region;
GdkWindowObject *impl_window;
GdkWindowImplIface *impl_iface;
gboolean expose;
{
GdkWindowObject *private = (GdkWindowObject *) window;
GdkWindowObject *impl_window;
- GdkRegion *copy_area, *noncopy_area;
- GdkRegion *old_native_child_region, *new_native_child_region;
+ cairo_region_t *copy_area, *noncopy_area;
+ cairo_region_t *old_native_child_region, *new_native_child_region;
GList *tmp_list;
g_return_if_fail (GDK_IS_WINDOW (window));
/**
* gdk_window_move_region:
* @window: a #GdkWindow
- * @region: The #GdkRegion to move
+ * @region: The #cairo_region_t to move
* @dx: Amount to move in the X direction
* @dy: Amount to move in the Y direction
*
*/
void
gdk_window_move_region (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
gint dx,
gint dy)
{
GdkWindowObject *private = (GdkWindowObject *) window;
GdkWindowObject *impl_window;
- GdkRegion *nocopy_area;
- GdkRegion *copy_area;
+ cairo_region_t *nocopy_area;
+ cairo_region_t *copy_area;
g_return_if_fail (GDK_IS_WINDOW (window));
g_return_if_fail (region != NULL);
gint y)
{
GdkWindowObject *private;
- GdkRegion *region;
+ cairo_region_t *region;
g_return_if_fail (GDK_IS_WINDOW (window));
*/
void
gdk_window_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
GdkWindowObject *private;
- GdkRegion *old_region, *new_region, *diff;
+ cairo_region_t *old_region, *new_region, *diff;
g_return_if_fail (GDK_IS_WINDOW (window));
{
GdkWindowObject *private;
GdkRectangle r;
- GdkRegion *region;
+ cairo_region_t *region;
private = (GdkWindowObject *) window;
gint y)
{
GdkWindowObject *private;
- GdkRegion *region;
+ cairo_region_t *region;
g_return_if_fail (GDK_IS_WINDOW (window));
*/
void
gdk_window_input_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
{
GdkWindowObject *private;
GdkRectangle r;
- GdkRegion *region;
+ cairo_region_t *region;
private = (GdkWindowObject *) window;
/* Calculates the real clipping region for a window, in window coordinates,
* taking into account other windows, gc clip region and gc clip mask.
*/
-GdkRegion *
+cairo_region_t *
_gdk_window_calculate_full_clip_region (GdkWindow *window,
GdkWindow *base_window,
gboolean do_children,
{
GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
GdkRectangle visible_rect;
- GdkRegion *real_clip_region, *tmpreg;
+ cairo_region_t *real_clip_region, *tmpreg;
gint x_offset, y_offset;
GdkWindowObject *parentwin, *lastwin;
void
_gdk_window_add_damage (GdkWindow *toplevel,
- GdkRegion *damaged_region)
+ cairo_region_t *damaged_region)
{
GdkDisplay *display;
GdkEvent event = { 0, };
GSList *GSEAL (paint_stack);
- GdkRegion *GSEAL (update_area);
+ cairo_region_t *GSEAL (update_area);
guint GSEAL (update_freeze_count);
guint8 GSEAL (window_type);
gint dx,
gint dy);
void gdk_window_move_region (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
gint dx,
gint dy);
gboolean gdk_window_ensure_native (GdkWindow *window);
gint x,
gint y);
void gdk_window_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y);
gint x,
gint y);
void gdk_window_input_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y);
void gdk_window_set_child_input_shapes (GdkWindow *window);
void gdk_window_begin_paint_rect (GdkWindow *window,
const GdkRectangle *rectangle);
void gdk_window_begin_paint_region (GdkWindow *window,
- const GdkRegion *region);
+ const cairo_region_t *region);
void gdk_window_end_paint (GdkWindow *window);
void gdk_window_flush (GdkWindow *window);
const GdkRectangle *rect,
gboolean invalidate_children);
void gdk_window_invalidate_region (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
gboolean invalidate_children);
void gdk_window_invalidate_maybe_recurse (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
gboolean (*child_func) (GdkWindow *, gpointer),
gpointer user_data);
-GdkRegion *gdk_window_get_update_area (GdkWindow *window);
+cairo_region_t *gdk_window_get_update_area (GdkWindow *window);
void gdk_window_freeze_updates (GdkWindow *window);
void gdk_window_thaw_updates (GdkWindow *window);
gint x,
gint y);
void (* clear_region) (GdkWindow *window,
- GdkRegion *region,
+ cairo_region_t *region,
gboolean send_expose);
void (* set_device_cursor) (GdkWindow *window,
GdkModifierType *mask);
void (* shape_combine_region) (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y);
void (* input_shape_combine_region) (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y);
* for destroying the region later.
*/
gboolean (* queue_antiexpose) (GdkWindow *window,
- GdkRegion *update_area);
+ cairo_region_t *update_area);
void (* queue_translation) (GdkWindow *window,
GdkGC *gc,
- GdkRegion *area,
+ cairo_region_t *area,
gint dx,
gint dy);
gint width;
gint height;
- GdkRegion *damage;
+ cairo_region_t *damage;
guint damage_idle;
};
*/
#import "GdkQuartzView.h"
-#include "gdkregion.h"
-#include "gdkregion-generic.h"
#include "gdkwindow-quartz.h"
#include "gdkprivate-quartz.h"
#include "gdkquartz.h"
void
_gdk_windowing_gc_set_clip_region (GdkGC *gc,
- const GdkRegion *region,
+ const cairo_region_t *region,
gboolean reset_origin)
{
GdkGCQuartz *private = GDK_GC_QUARTZ (gc);
void
_gdk_quartz_window_queue_translation (GdkWindow *window,
GdkGC *gc,
- GdkRegion *area,
+ cairo_region_t *area,
gint dx,
gint dy)
{
GdkWindowImplQuartz *impl = (GdkWindowImplQuartz *)private->impl;
int i, n_rects;
- GdkRegion *intersection;
+ cairo_region_t *intersection;
GdkRectangle rect;
/* We will intersect the known region that needs display with the given
gboolean
_gdk_quartz_window_queue_antiexpose (GdkWindow *window,
- GdkRegion *area)
+ cairo_region_t *area)
{
return FALSE;
}
gint number);
void _gdk_quartz_window_set_needs_display_in_region (GdkWindow *window,
- GdkRegion *region);
+ cairo_region_t *region);
void _gdk_quartz_window_update_position (GdkWindow *window);
gint dy);
void _gdk_quartz_window_queue_translation (GdkWindow *window,
GdkGC *gc,
- GdkRegion *area,
+ cairo_region_t *area,
gint dx,
gint dy);
gboolean _gdk_quartz_window_queue_antiexpose (GdkWindow *window,
- GdkRegion *area);
+ cairo_region_t *area);
#endif /* __GDK_PRIVATE_QUARTZ_H__ */
static void
gdk_window_impl_quartz_begin_paint_region (GdkPaintable *paintable,
GdkWindow *window,
- const GdkRegion *region)
+ const cairo_region_t *region)
{
GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (paintable);
GdkWindowObject *private = (GdkWindowObject*)window;
int n_rects;
GdkPixmap *bg_pixmap;
- GdkRegion *clipped_and_offset_region;
+ cairo_region_t *clipped_and_offset_region;
gboolean free_clipped_and_offset_region = TRUE;
bg_pixmap = private->bg_pixmap;
void
_gdk_quartz_window_set_needs_display_in_region (GdkWindow *window,
- GdkRegion *region)
+ cairo_region_t *region)
{
GdkWindowObject *private;
GdkWindowImplQuartz *impl;
void
_gdk_windowing_window_process_updates_recurse (GdkWindow *window,
- GdkRegion *region)
+ cairo_region_t *region)
{
/* Make sure to only flush each toplevel at most once if we're called
* from process_all_updates.
GdkRectangle old_visible;
GdkRectangle new_visible;
GdkRectangle scroll_rect;
- GdkRegion *old_region;
- GdkRegion *expose_region;
+ cairo_region_t *old_region;
+ cairo_region_t *expose_region;
NSSize delta;
if (GDK_WINDOW_DESTROYED (window))
static void
gdk_window_quartz_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape,
+ const cairo_region_t *shape,
gint x,
gint y)
{
static void
gdk_window_quartz_input_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
gboolean
_gdk_windowing_window_queue_antiexpose (GdkWindow *window,
- GdkRegion *area)
+ cairo_region_t *area)
{
return FALSE;
}
{
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_get_shape_for_mask (GdkBitmap *mask)
{
/* FIXME: implement */
return NULL;
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_window_get_shape (GdkWindow *window)
{
/* FIXME: implement */
return NULL;
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_window_get_input_shape (GdkWindow *window)
{
/* FIXME: implement */
GdkWindowTypeHint type_hint;
- GdkRegion *paint_clip_region;
+ cairo_region_t *paint_clip_region;
gint begin_paint_count;
gint in_paint_rect_count;
/* Sorted by z-order */
GList *sorted_children;
- GdkRegion *needs_display_region;
+ cairo_region_t *needs_display_region;
};
struct _GdkWindowImplQuartzClass
#include <cairo-win32.h>
#include "gdkscreen.h" /* gdk_screen_get_default() */
-#include "gdkregion-generic.h"
#include "gdkprivate-win32.h"
#define ROP3_D 0x00AA0029
GdkGC *gc,
GdkGCValuesMask mask,
void (*function) (GdkGCWin32 *, HDC, gint, gint, va_list),
- const GdkRegion *region,
+ const cairo_region_t *region,
...)
{
GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
va_end (args);
}
-static GdkRegion *
+static cairo_region_t *
widen_bounds (GdkRectangle *bounds,
gint pen_width)
{
gint height)
{
GdkRectangle bounds;
- GdkRegion *region;
+ cairo_region_t *region;
GDK_NOTE (DRAW, g_print ("gdk_win32_draw_rectangle: %s (%p) %s%dx%d@%+d%+d\n",
_gdk_win32_drawable_description (drawable),
gint angle2)
{
GdkRectangle bounds;
- GdkRegion *region;
+ cairo_region_t *region;
GDK_NOTE (DRAW, g_print ("gdk_win32_draw_arc: %s %d,%d,%d,%d %d %d\n",
_gdk_win32_drawable_description (drawable),
gint npoints)
{
GdkRectangle bounds;
- GdkRegion *region;
+ cairo_region_t *region;
POINT *pts;
int i;
gint nsegs)
{
GdkRectangle bounds;
- GdkRegion *region;
+ cairo_region_t *region;
gint i;
GDK_NOTE (DRAW, g_print ("gdk_win32_draw_segments: %s %d segs\n",
gint npoints)
{
GdkRectangle bounds;
- GdkRegion *region;
+ cairo_region_t *region;
POINT *pts;
int i;
}
}
-GdkRegion *
+cairo_region_t *
_gdk_win32_hrgn_to_region (HRGN hrgn)
{
RGNDATA *rgndata;
RECT *rects;
- GdkRegion *result;
+ cairo_region_t *result;
gint nbytes;
guint i;
HRGN hrgn = CreateRectRgn (0, 0, 0, 0);
HDC hdc;
PAINTSTRUCT paintstruct;
- GdkRegion *update_region;
+ cairo_region_t *update_region;
if (GetUpdateRgn (msg->hwnd, hrgn, FALSE) == ERROR)
{
#include "gdkgc.h"
#include "gdkpixmap.h"
-#include "gdkregion-generic.h"
#include "gdkprivate-win32.h"
static void gdk_win32_gc_get_values (GdkGC *gc,
void
_gdk_windowing_gc_set_clip_region (GdkGC *gc,
- const GdkRegion *region,
+ const cairo_region_t *region,
gboolean reset_origin)
{
GdkGCWin32 *win32_gc = GDK_GC_WIN32 (gc);
}
HRGN
-_gdk_win32_gdkregion_to_hrgn (const GdkRegion *region,
+_gdk_win32_gdkregion_to_hrgn (const cairo_region_t *region,
gint x_origin,
gint y_origin)
{
HRGN hrgn;
RGNDATA *rgndata;
RECT *rect;
- GdkRegionBox *boxes = region->rects;
+ cairo_region_tBox *boxes = region->rects;
guint nbytes =
sizeof (RGNDATAHEADER) + (sizeof (RECT) * region->numRects);
int i;
#include "config.h"
#include "gdk.h" /* For gdk_rectangle_intersect */
-#include "gdkregion.h"
-#include "gdkregion-generic.h"
#include "gdkinternals.h"
#include "gdkprivate-win32.h"
*/
#if 0
-static GdkRegion *
+static cairo_region_t *
gdk_window_clip_changed (GdkWindow *window,
GdkRectangle *old_clip,
GdkRectangle *new_clip)
{
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
- GdkRegion *old_clip_region;
- GdkRegion *new_clip_region;
+ cairo_region_t *old_clip_region;
+ cairo_region_t *new_clip_region;
if (((GdkWindowObject *)window)->input_only)
return NULL;
#if 0
static void
gdk_window_post_scroll (GdkWindow *window,
- GdkRegion *new_clip_region)
+ cairo_region_t *new_clip_region)
{
GDK_NOTE (EVENTS,
g_print ("gdk_window_clip_changed: invalidating region: %s\n",
#include <io.h>
#include "gdk.h"
-#include "gdkregion-generic.h"
#include "gdkkeysyms.h"
#include "gdkinternals.h"
#include "gdkintl.h"
}
gchar *
-_gdk_win32_gdkregion_to_string (const GdkRegion *rgn)
+_gdk_win32_gdkregion_to_string (const cairo_region_t *rgn)
{
return static_printf ("%dx%d@%+d%+d",
(rgn->extents.x2 - rgn->extents.x1),
gint dx,
gint dy);
void _gdk_win32_window_move_region (GdkWindow *window,
- const GdkRegion *region,
+ const cairo_region_t *region,
gint dx,
gint dy);
void _gdk_win32_windowing_window_get_offsets (GdkWindow *window,
HRGN _gdk_win32_bitmap_to_hrgn (GdkPixmap *bitmap);
-HRGN _gdk_win32_gdkregion_to_hrgn (const GdkRegion *region,
+HRGN _gdk_win32_gdkregion_to_hrgn (const cairo_region_t *region,
gint x_origin,
gint y_origin);
-GdkRegion *_gdk_win32_hrgn_to_region (HRGN hrgn);
+cairo_region_t *_gdk_win32_hrgn_to_region (HRGN hrgn);
void _gdk_win32_adjust_client_rect (GdkWindow *window,
RECT *RECT);
gchar *_gdk_win32_rect_to_string (const RECT *rect);
gchar *_gdk_win32_gdkrectangle_to_string (const GdkRectangle *rect);
-gchar *_gdk_win32_gdkregion_to_string (const GdkRegion *box);
+gchar *_gdk_win32_gdkregion_to_string (const cairo_region_t *box);
void _gdk_win32_print_event (const GdkEvent *event);
static void
gdk_win32_window_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
}
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_get_shape_for_mask (GdkBitmap *mask)
{
- GdkRegion *region;
+ cairo_region_t *region;
HRGN hrgn = _gdk_win32_bitmap_to_hrgn (mask);
region = _gdk_win32_hrgn_to_region (hrgn);
{
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_window_get_shape (GdkWindow *window)
{
HRGN hrgn = CreateRectRgn (0, 0, 0, 0);
if (type == SIMPLEREGION || type == COMPLEXREGION)
{
- GdkRegion *region = _gdk_win32_hrgn_to_region (hrgn);
+ cairo_region_t *region = _gdk_win32_hrgn_to_region (hrgn);
DeleteObject (hrgn);
return region;
return NULL;
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_window_get_input_shape (GdkWindow *window)
{
/* CHECK: are these really supposed to be the same? */
static gboolean
_gdk_win32_window_queue_antiexpose (GdkWindow *window,
- GdkRegion *area)
+ cairo_region_t *area)
{
HRGN hrgn = _gdk_win32_gdkregion_to_hrgn (area, 0, 0);
static void
_gdk_win32_window_queue_translation (GdkWindow *window,
GdkGC *gc,
- GdkRegion *area,
+ cairo_region_t *area,
gint dx,
gint dy)
{
static void
gdk_win32_input_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
void
_gdk_windowing_window_process_updates_recurse (GdkWindow *window,
- GdkRegion *region)
+ cairo_region_t *region)
{
_gdk_window_process_updates_recurse (window, region);
}
gboolean mapped;
gboolean shape_selected;
gboolean shape_valid;
- GdkRegion *shape;
+ cairo_region_t *shape;
} GdkCacheChild;
typedef struct {
if (!child->shape_valid)
{
GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
- GdkRegion *input_shape;
+ cairo_region_t *input_shape;
child->shape = _xwindow_get_shape (display_x11->xdisplay,
child->xid, ShapeBounding);
GdkDrawableImplX11 *impl = GDK_DRAWABLE_IMPL_X11 (drawable);
Display *xdisplay = GDK_SCREEN_XDISPLAY (impl->screen);
Picture picture = gdk_x11_drawable_get_picture (drawable);
- GdkRegion *clip_region = gc ? _gdk_gc_get_clip_region (gc) : NULL;
+ cairo_region_t *clip_region = gc ? _gdk_gc_get_clip_region (gc) : NULL;
if (clip_region)
{
if (private->dirty_mask & GDK_GC_DIRTY_CLIP)
{
- GdkRegion *clip_region = _gdk_gc_get_clip_region (gc);
+ cairo_region_t *clip_region = _gdk_gc_get_clip_region (gc);
if (!clip_region)
XSetClipOrigin (xdisplay, xgc,
void
_gdk_windowing_gc_set_clip_region (GdkGC *gc,
- const GdkRegion *region,
+ const cairo_region_t *region,
gboolean reset_origin)
{
GdkGCX11 *x11_gc = GDK_GC_X11 (gc);
#include "gdk.h" /* For gdk_rectangle_intersect */
#include "gdkprivate-x11.h"
#include "gdkx.h"
-#include "gdkregion.h"
#include "gdkinternals.h"
#include "gdkscreen-x11.h"
#include "gdkdisplay-x11.h"
GdkWindowQueueType type;
union {
struct {
- GdkRegion *area;
+ cairo_region_t *area;
gint dx;
gint dy;
} translate;
struct {
- GdkRegion *area;
+ cairo_region_t *area;
} antiexpose;
} u;
};
void
_gdk_x11_window_queue_translation (GdkWindow *window,
GdkGC *gc,
- GdkRegion *area,
+ cairo_region_t *area,
gint dx,
gint dy)
{
gboolean
_gdk_x11_window_queue_antiexpose (GdkWindow *window,
- GdkRegion *area)
+ cairo_region_t *area)
{
GdkWindowQueueItem *item = g_new (GdkWindowQueueItem, 1);
item->type = GDK_WINDOW_QUEUE_ANTIEXPOSE;
gulong serial,
GdkRectangle *area)
{
- GdkRegion *invalidate_region = cairo_region_create_rectangle (area);
+ cairo_region_t *invalidate_region = cairo_region_create_rectangle (area);
GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (GDK_WINDOW_DISPLAY (window));
if (display_x11->translate_queue)
{
if (item->u.translate.area)
{
- GdkRegion *intersection;
+ cairo_region_t *intersection;
intersection = cairo_region_copy (invalidate_region);
cairo_region_intersect (intersection, item->u.translate.area);
}
void
-_gdk_region_get_xrectangles (const GdkRegion *region,
+_gdk_region_get_xrectangles (const cairo_region_t *region,
gint x_offset,
gint y_offset,
XRectangle **rects,
GdkRectangle *area);
gboolean _gdk_x11_window_queue_antiexpose (GdkWindow *window,
- GdkRegion *area);
+ cairo_region_t *area);
void _gdk_x11_window_queue_translation (GdkWindow *window,
GdkGC *gc,
- GdkRegion *area,
+ cairo_region_t *area,
gint dx,
gint dy);
void _gdk_selection_window_destroyed (GdkWindow *window);
gboolean _gdk_selection_filter_clear_event (XSelectionClearEvent *event);
-GdkRegion* _xwindow_get_shape (Display *xdisplay,
+cairo_region_t* _xwindow_get_shape (Display *xdisplay,
Window window,
gint shape_type);
-void _gdk_region_get_xrectangles (const GdkRegion *region,
+void _gdk_region_get_xrectangles (const cairo_region_t *region,
gint x_offset,
gint y_offset,
XRectangle **rects,
#include "gdkasync.h"
#include "gdkdisplay-x11.h"
#include "gdkprivate-x11.h"
-#include "gdkregion.h"
#include "gdkinternals.h"
#include "MwmUtil.h"
#include "gdkwindow-x11.h"
static void
gdk_window_x11_clear_region (GdkWindow *window,
- GdkRegion *region,
+ cairo_region_t *region,
gboolean send_expose)
{
cairo_rectangle_int_t rect;
static inline void
do_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y,
gint shape)
static void
gdk_window_x11_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
static void
gdk_window_x11_input_shape_combine_region (GdkWindow *window,
- const GdkRegion *shape_region,
+ const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
gdk_window_set_mwm_hints (window, &hints);
}
-GdkRegion *
+cairo_region_t *
_xwindow_get_shape (Display *xdisplay,
Window window,
gint shape_type)
{
- GdkRegion *shape;
+ cairo_region_t *shape;
GdkRectangle *rl;
XRectangle *xrl;
gint rn, ord, i;
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_get_shape_for_mask (GdkBitmap *mask)
{
GdkDisplay *display;
Window window;
- GdkRegion *region;
+ cairo_region_t *region;
display = gdk_drawable_get_display (GDK_DRAWABLE (mask));
return region;
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_window_get_shape (GdkWindow *window)
{
if (!GDK_WINDOW_DESTROYED (window) &&
return NULL;
}
-GdkRegion *
+cairo_region_t *
_gdk_windowing_window_get_input_shape (GdkWindow *window)
{
#if defined(ShapeInput)
void
_gdk_windowing_window_process_updates_recurse (GdkWindow *window,
- GdkRegion *region)
+ cairo_region_t *region)
{
_gdk_window_process_updates_recurse (window, region);
}
GdkRectangle old_area;
GdkRectangle new_area;
GdkRectangle common;
- GdkRegion *invalid_region;
+ cairo_region_t *invalid_region;
icon_view = GTK_ICON_VIEW (data);
gdk_rectangle_intersect (&old_area, &new_area, &common);
if (common.width > 2 && common.height > 2)
{
- GdkRegion *common_region;
+ cairo_region_t *common_region;
/* make sure the border is invalidated */
common.x += 1;
(info->selection_anchor != info->selection_end))
{
gint range[2];
- GdkRegion *clip;
+ cairo_region_t *clip;
GtkStateType state;
range[0] = info->selection_anchor;
GtkLabelLink *focus_link;
GtkLabelLink *active_link;
gint range[2];
- GdkRegion *clip;
+ cairo_region_t *clip;
GdkRectangle rect;
GdkColor *text_color;
GdkColor *base_color;
/* When a submenu of this menu is popped up, motion in this
* region is ignored
*/
- GdkRegion *GSEAL (navigation_region); /* unused */
+ cairo_region_t *GSEAL (navigation_region); /* unused */
guint GSEAL (navigation_timeout);
guint GSEAL (needs_destruction_ref_count) : 1;
}
-static GdkRegion *
+static cairo_region_t *
get_selected_clip (GtkTextRenderer *text_renderer,
PangoLayout *layout,
PangoLayoutLine *line,
{
gint *ranges;
gint n_ranges, i;
- GdkRegion *clip_region = cairo_region_create ();
- GdkRegion *tmp_region;
+ cairo_region_t *clip_region = cairo_region_create ();
+ cairo_region_t *tmp_region;
pango_layout_line_get_x_ranges (line, start_index, end_index, &ranges, &n_ranges);
(selection_start_index == byte_offset + line->length && pango_layout_iter_at_last_line (iter))) &&
selection_end_index > byte_offset)
{
- GdkRegion *clip_region = get_selected_clip (text_renderer, layout, line,
+ cairo_region_t *clip_region = get_selected_clip (text_renderer, layout, line,
x + line_display->x_offset,
selection_y,
selection_height,
GdkRectangle old_area;
GdkRectangle new_area;
GdkRectangle common;
- GdkRegion *invalid_region;
+ cairo_region_t *invalid_region;
old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
gdk_rectangle_intersect (&old_area, &new_area, &common);
if (common.width > 2 && common.height > 2)
{
- GdkRegion *common_region;
+ cairo_region_t *common_region;
/* make sure the border is invalidated */
common.x += 1;
static void gtk_widget_accessible_interface_init (AtkImplementorIface *iface);
static AtkObject* gtk_widget_ref_accessible (AtkImplementor *implementor);
static void gtk_widget_invalidate_widget_windows (GtkWidget *widget,
- GdkRegion *region);
+ cairo_region_t *region);
static GdkScreen * gtk_widget_get_screen_unchecked (GtkWidget *widget);
static void gtk_widget_queue_shallow_draw (GtkWidget *widget);
static gboolean gtk_widget_real_can_activate_accel (GtkWidget *widget,
*/
static void
gtk_widget_invalidate_widget_windows (GtkWidget *widget,
- GdkRegion *region)
+ cairo_region_t *region)
{
if (!gtk_widget_get_realized (widget))
return;
gtk_widget_queue_shallow_draw (GtkWidget *widget)
{
GdkRectangle rect;
- GdkRegion *region;
+ cairo_region_t *region;
if (!gtk_widget_get_realized (widget))
return;
{
/* Invalidate union(old_allaction,widget->allocation) in widget->window
*/
- GdkRegion *invalidate = cairo_region_create_rectangle (&widget->allocation);
+ cairo_region_t *invalidate = cairo_region_create_rectangle (&widget->allocation);
cairo_region_union_rectangle (invalidate, &old_allocation);
gdk_window_invalidate_region (widget->window, invalidate, FALSE);
{
/* Invalidate union(old_allaction,widget->allocation) in widget->window and descendents owned by widget
*/
- GdkRegion *invalidate = cairo_region_create_rectangle (&widget->allocation);
+ cairo_region_t *invalidate = cairo_region_create_rectangle (&widget->allocation);
cairo_region_union_rectangle (invalidate, &old_allocation);
gtk_widget_invalidate_widget_windows (widget, invalidate);
if ((size_changed || position_changed) && widget->parent &&
gtk_widget_get_realized (widget->parent) && GTK_CONTAINER (widget->parent)->reallocate_redraws)
{
- GdkRegion *invalidate = cairo_region_create_rectangle (&widget->parent->allocation);
+ cairo_region_t *invalidate = cairo_region_create_rectangle (&widget->parent->allocation);
gtk_widget_invalidate_widget_windows (widget->parent, invalidate);
cairo_region_destroy (invalidate);
}
/**
* gtk_widget_region_intersect:
* @widget: a #GtkWidget
- * @region: a #GdkRegion, in the same coordinate system as
+ * @region: a #cairo_region_t, in the same coordinate system as
* @widget->allocation. That is, relative to @widget->window
* for %NO_WINDOW widgets; relative to the parent window
* of @widget->window for widgets with their own window.
* the intersection. The result may be empty, use cairo_region_is_empty() to
* check.
**/
-GdkRegion *
+cairo_region_t *
gtk_widget_region_intersect (GtkWidget *widget,
- const GdkRegion *region)
+ const cairo_region_t *region)
{
GdkRectangle rect;
- GdkRegion *dest;
+ cairo_region_t *dest;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
g_return_val_if_fail (region != NULL, NULL);
gboolean gtk_widget_intersect (GtkWidget *widget,
const GdkRectangle *area,
GdkRectangle *intersection);
-GdkRegion *gtk_widget_region_intersect (GtkWidget *widget,
- const GdkRegion *region);
+cairo_region_t *gtk_widget_region_intersect (GtkWidget *widget,
+ const cairo_region_t *region);
void gtk_widget_freeze_child_notify (GtkWidget *widget);
void gtk_widget_child_notify (GtkWidget *widget,
window_expose_event (GtkWidget *widget,
GdkEventExpose *event)
{
- GdkRegion *region;
+ cairo_region_t *region;
GtkWidget *child;
cairo_t *cr;
if (!with_region)
{
- GdkRegion *region;
+ cairo_region_t *region;
gint x, y;
with_region = shape_create_icon (screen, "3DRings.xpm",
projects / gtk4.git / commitdiff